#define _CRT_SECURE_NO_WARNINGS

//#include <iostream>
//
//using namespace std;


//class Rational
//{
//	friend istream& operator>>(istream& in, Rational& obj);
//	friend Rational operator*(const Rational& a, const Rational& b);
//	friend Rational operator/(const Rational& a, const Rational& b);
//private:
//
//	int numerator;//分子
//
//	int denominator;//分母
//
//	static int gcd(int a, int b)//求两个数最大公约数
//	{
//		int great = a > b ? a : b;
//		int least = a < b ? a : b;
//		int r = great % least;
//		for (;;)
//		{
//			if (r == 0) return least;
//			great = least;
//			least = r;
//			r = great % least;
//		}
//		return 0;
//	}
//
//public:
//
//	Rational()//分子为0，分母为1
//	{
//		numerator = 0;
//		denominator = 1;
//	}
//
//	Rational(int a, int b)//调用gcd()函数，将分子和分母除以它们最大公约数后再保存，如果存在负号，保存在分子中，例如输入参数为3，-6为分子分母，那么化简后分子为-1，分母为2
//	{
//		int ret = gcd(a, b);
//		numerator = a / ret;
//		denominator = b / abs(ret);
//	}
//
//	Rational(int a)//类型转换构造函数，用参数初始化分子，分母为1
//	{
//		numerator = a;
//		denominator = 1;
//	}
//
//	int getNumerator()const
//	{
//		return numerator;
//	}
//
//	int getDenominator()const
//	{
//		return denominator;
//	}
//
//	void setNumerator(int a)
//	{
//		numerator = a;
//	}
//
//	void setDenominator(int b)
//	{
//		denominator = b;
//	}
//
//	int compareTo(const Rational& that) const//如果当前有理数大返回1，相等返回0，小的话返回-1，可以在比较类运算符重载函数中调用此函数
//	{
//		double a = (double)numerator / denominator;
//		double b = (double)that.numerator / that.denominator;
//		if (a > b) return 1;
//		else if (a < b) return -1;
//		else if (a == b) return 0;
//	}
//
//	bool equals(const Rational& that) const//比较两个有理数是否相等
//	{
//		return !compareTo(that);
//	}
//
//	int& operator[](int index)//索引为0返回分子，其他返回分母
//	{
//		if (!index) return numerator;
//		else return denominator;
//	}
//
//	Rational& operator++()
//	{
//		numerator += denominator;
//		return *this;
//	}
//
//	Rational& operator--()
//	{
//		numerator -= denominator;
//		return *this;
//	}
//	Rational operator++(int)
//	{
//		Rational ret = *this;
//		numerator += denominator;
//		return ret;
//	}
//
//	Rational operator--(int)
//	{
//		Rational ret = *this;
//		numerator -= denominator;
//		return ret;
//	}
//
//	Rational operator-()//取负
//	{
//		Rational ret = *this;	
//		ret.numerator = -numerator;
//		return ret;
//	}
//
//	Rational& operator+=(const Rational& that)
//	{
//		int commonDown = denominator * that.denominator / gcd(denominator, that.denominator);
//		numerator = numerator * (commonDown / denominator) + that.numerator * (commonDown / that.denominator);
//		denominator = commonDown;
//		return *this;
//	}
//
//	Rational& operator-=(const Rational& that)
//	{
//		int commonDown = denominator * that.denominator / gcd(denominator, that.denominator);
//		numerator = numerator * (commonDown / denominator) - that.numerator * (commonDown / that.denominator);
//		denominator = commonDown;
//		return *this;
//	}
//
//	Rational& operator*=(const Rational& that)
//	{
//		numerator *= that.numerator;
//		denominator *= that.denominator;
//		return *this;
//	}
//
//	Rational& operator/=(const Rational& that)
//	{
//		numerator *= that.denominator;
//		denominator *= that.numerator;
//		if (denominator < 0) denominator = -denominator, numerator = -numerator;
//		return *this;
//	}
//
//	operator double()//强制类型转换，得到相除的结果值
//	{
//		return (double)((double)numerator / (double)denominator);
//	}
//
//};
//
//Rational operator+(const Rational& a, const Rational& b)
//{
//	Rational ret = (Rational&)a;
//	ret += b;
//	return ret;
//}
//
//Rational operator-(const Rational& a, const Rational& b)
//{
//	Rational ret = (Rational&)a;
//	ret -= b;
//	return ret;
//}
//
//Rational operator*(const Rational& a, const Rational& b)
//{
//	Rational ret = (Rational&)a;
//	ret *= b;
//	int a1 = ret.getNumerator(), b1 = ret.getDenominator();
//	int gcd = abs(Rational::gcd(a1, b1));
//	ret.setNumerator(a1 / gcd);
//	ret.setDenominator(b1 / gcd);
//	return ret;
//}
//
//Rational operator/(const Rational& a, const Rational& b)
//{
//	Rational ret = (Rational&)a;
//	ret /= b;
//	int a1 = ret.getNumerator(), b1 = ret.getDenominator();
//	int gcd = abs(Rational::gcd(a1, b1));
//	ret.setNumerator(a1 / gcd);
//	ret.setDenominator(b1 / gcd);
//	return ret;
//}
//
//bool operator<(const Rational& a, const Rational& b)
//{
//	if (a.compareTo(b) == -1) return true;
//	else return false;
//}
//
//bool operator<=(const Rational& a, const Rational& b)
//{
//	if (a.compareTo(b) == 1) return false;
//	else return true;
//}
//
//bool operator>(const Rational& a, const Rational& b)
//{
//	if (a.compareTo(b) == 1) return true;
//	else return false;
//}
//
//bool operator>=(const Rational& a, const Rational& b)
//{
//	if (a.compareTo(b) == -1) return false;
//	else return true;
//}
//
//bool operator==(const Rational& a, const Rational& b)
//{
//	if (a.compareTo(b) == 0) return true;
//	else return false;
//}
//
//bool operator!=(const Rational& a, const Rational& b)
//{
//	if (a.compareTo(b) == 0) return false;
//	else return true;
//}
//
//ostream& operator<<(ostream& out, const Rational& obj)//输出格式为-1/2这样的形式，如果分母为1不输出分母。
//{
//	out << obj.getNumerator();
//	if (obj.getDenominator() != 1)
//	{
//		out << '/' << obj.getDenominator();
//	}
//	return out;
//}
//
//istream& operator>>(istream& in, Rational& obj)//读入两个整数
//{
//	int a, b;
//	in >> a >> b;
//	int gcd = Rational::gcd(a, b);
//	a /= gcd;
//	b /= gcd;
//	obj.setNumerator(a);
//	obj.setDenominator(b);
//	return in;
//}
//
//int main()
//{
//	Rational a, b;
//	cin >> a >> b;
//	cout << "The value of " << a << " is " << (double)a << "." << endl;//调用double()强制类型转换运算符重载
//	cout << "The value of " << b << " is " << (double)b << "." << endl;//调用double()强制类型转换运算符重载
//
//	cout << "(" << a << ")" << ">(" << b << ") is ";
//	if (a > b) cout << "true." << endl;
//	else cout << "false." << endl;
//
//	cout << "(" << a << ")" << "=>(" << b << ") is ";
//	if (a >= b) cout << "true." << endl;
//	else cout << "false." << endl;
//
//	cout << "(" << a << ")" << "<(" << b << ") is ";
//	if (a < b) cout << "true." << endl;
//	else cout << "false." << endl;
//
//	cout << "(" << a << ")" << "<=(" << b << ") is ";
//	if (a <= b) cout << "true." << endl;
//	else cout << "false." << endl;
//
//	cout << "(" << a << ")" << "==(" << b << ") is ";
//	if (a == b) cout << "true." << endl;
//	else cout << "false." << endl;
//
//	cout << "(" << a << ")" << "!=(" << b << ") is ";
//	if (a != b) cout << "true." << endl;
//	else cout << "false." << endl;
//
//	cout << "(" << a << ")+(" << b << ")=" << a + b << endl;
//	cout << "(" << a << ")-(" << b << ")=" << a - b << endl;
//	cout << "(" << a << ")*(" << b << ")=" << a * b << endl;
//	cout << "(" << a << ")/(" << b << ")=" << a / b << endl;
//
//	cout << "-(" << a << ")=" << -a << endl;
//	cout << "-(" << b << ")=" << -b << endl;
//
//	cout << "(" << a << ")[0]=" << a[0] << endl;
//	cout << "(" << a << ")[1]=" << a[1] << endl;
//	cout << "(" << b << ")[0]=" << b[0] << endl;
//	cout << "(" << b << ")[1]=" << b[1] << endl;
//
//	cout << "++(" << a << ")=";
//	cout << ++a << endl;
//	cout << "(" << a << ")++=";
//	cout << a++ << endl;
//	cout << "--(" << a << ")=";
//	cout << --a << endl;
//	cout << "(" << a << ")--=";
//	cout << a-- << endl;
//
//	cout << "++(" << b << ")=";
//	cout << ++b << endl;
//	cout << "(" << b << ")++=";
//	cout << b++ << endl;
//	cout << "--(" << b << ")=";
//	cout << --b << endl;
//	cout << "(" << b << ")--=";
//	cout << b-- << endl;
//
//	return 0;
//}

//#include <iostream>
//#include <cstring>
//
//using namespace std;
//
//class myString
//{
//	friend bool operator>(const myString& str1, const myString& str2);
//	friend bool operator==(const myString& str1, const myString& str2);
//private:
//
//	char* buffer;
//	size_t len;
//	size_t capa;
//
//public:
//
//	myString() { buffer = nullptr, capa = 0, len = 0; };
//
//	myString(const char& c)
//	{
//		len = capa = strlen(&c);
//		buffer = new char[len];
//		memmove(buffer, &c, len);
//	}
//
//	myString(const char* cStr)
//	{
//		len = capa = strlen(cStr);
//		buffer = new char[len];
//		memmove(buffer, cStr, len);
//	}
//
//	myString(const myString& s)
//	{
//		len = s.len;
//		capa = s.capa;
//		buffer = new char[s.capa];
//		memmove(buffer, s.buffer, s.len);
//	}
//
//	~myString()
//	{
//		delete[] buffer;
//		buffer = nullptr;
//		len = capa = 0;
//	}
//
//	void reserve(size_t newcapa)
//	{
//		char* newbuffer = new char[newcapa];
//		if (buffer)
//		{
//			memmove(newbuffer, buffer, capa);
//			delete[] buffer;
//		}
//		capa = newcapa;
//		buffer = newbuffer;
//	}
//
//	myString& operator=(const myString& s)
//	{
//		delete[] buffer;
//		len = s.len;
//		capa = s.capa;
//		buffer = new char[s.capa];
//		memmove(buffer, s.buffer, s.len);
//		return *this;
//	}
//
//	myString& operator=(const char& c)
//	{
//		delete[] buffer;
//		len = capa = strlen(&c);
//		buffer = new char[len];
//		memmove(buffer, &c, len);
//		return *this;
//	}
//
//	myString& operator=(const char* cStr)
//	{
//		delete[] buffer;
//		len = capa = strlen(cStr);
//		buffer = new char[len];
//		memmove(buffer, cStr, len);
//		return *this;
//	}
//
//	int getLength()const { return len; }
//
//	char& operator[](const int& index) const
//	{
//		return buffer[index];
//	}
//
//	void append(const char& c)
//	{
//		if(len >= capa) reserve(capa == 0 ? 10 : 2 * capa);
//		buffer[len] = c;
//		len++;
//	}
//
//	void append(const myString& s)
//	{
//		if (len + s.len > capa) reserve(capa == 0 ? 10 : 2 * capa);
//		int i = 0, j = 0;
//		for (i = len, j = 0; j < s.len; i++, j++)
//		{
//			buffer[i] = s[j];
//		}
//		len += s.len;
//	}
//
//	void append(const char* cStr)
//	{
//		size_t cStrLen = strlen(cStr);
//		if (len + cStrLen > capa) reserve(capa == 0 ? 10 : 2 * capa);
//		int i = 0, j = 0;
//		for (i = len, j = 0; j < cStrLen; i++, j++)
//		{
//			buffer[i] = cStr[j];
//		}
//		len += cStrLen;
//	}
//
//	int findCharIndex(const char& c, const int& startIndex) const//查找
//	{
//		for (int i = startIndex; i < len; i++)
//		{
//			if (c == buffer[i]) return i;
//		}
//		return -1;
//	}
//
//	int countChar(const char& c) const//字符出现次数
//	{
//		int count = 0;
//		for (int i = 0; i < len; i++)
//		{
//			if (c == buffer[i]) count++;
//		}
//		return count;
//	}
//
//	myString getSubString(const int& startIndex, const int& count)const//子串
//	{
//		myString ret;
//		for (int i = startIndex; i < startIndex + count; i++)
//		{
//			ret.append(buffer[i]);
//		}
//		return ret;
//	}
//
//	void reverse()//字符串倒置
//	{
//		myString temp = "";
//		for (int i = len - 1; i >= 0; i--)
//		{
//			temp.append(buffer[i]);
//		}
//		(*this) = temp;
//	}
//
//	void removeChar(const char& c)//删除
//	{
//		myString temp = "";
//		for (int i = 0; i < len; i++)
//		{
//			if (buffer[i] == c) continue;
//			temp.append(buffer[i]);
//		}
//		*this = temp;
//	}
//
//	void replaceChar(const char& c1, const char& c2)//c2替换c1
//	{
//		for (int i = 0; i < len; i++)
//		{
//			if (buffer[i] == c1) buffer[i] = c2;
//		}
//	}
//
//	myString& operator+=(const char& c) { append(c); return *this; }
//
//	myString& operator+=(const myString& s) { append(s); return *this; }
//
//	myString& operator+=(const char* cStr) { append(cStr); return *this; }
//};
//
//myString operator+(const myString& str1, const myString& str2)
//{
//	myString res = str1;
//	res += str2;
//	return res;
//}
//
//bool operator==(const myString& str1, const myString& str2)
//{
//	if (strcmp(str1.buffer, str2.buffer) == 0) return true;
//	return false;
//}
//
//bool operator!=(const myString& str1, const myString& str2)
//{
//	if (str1 == str2) return false;
//	return true;
//}
//
//bool operator>(const myString& str1, const myString& str2)
//{
//	if (strcmp(str1.buffer, str2.buffer) > 0) return true;
//	return false;
//}
//
//bool operator>=(const myString& str1, const myString& str2)
//{
//	if (str1 > str2 || str1 == str2) return true;
//	return false;
//}
//
//bool operator<(const myString& str1, const myString& str2)
//{
//	if (str1 >= str2) return false;
//	return true;
//}
//
//bool operator<=(const myString& str1, const myString& str2)
//{
//	if (str1 < str2 || str1 == str2) return true;
//	return false;
//}
//
//ostream& operator<<(ostream& out, const myString& s)
//{
//	out << "\"";
//	for (int i = 0; i < s.getLength(); i++)
//	{
//		cout << s[i];
//	}
//	out << "\"";
//	return out;
//}
//
//istream& operator>>(istream& in, myString& s)
//{
//	char ch;
//
//	in >> ws;
//
//	for (; in.get(ch) && !isspace(ch);)
//	{
//		s.append(ch);
//	}
//
//	return in;
//}
//
//int main()
//{
//	myString s1, s2;
//	cin >> s1 >> s2;
//	cout << "s1=" << s1 << ">s2=" << s2 << " is ";
//	if (s1 > s2) cout << "true." << endl;
//	else cout << "false." << endl;
//
//	cout << "s1=" << s1 << ">=s2=" << s2 << " is ";
//	if (s1 >= s2) cout << "true." << endl;
//	else cout << "false." << endl;
//
//	cout << "s1=" << s1 << "<s2=" << s2 << " is ";
//	if (s1 < s2) cout << "true." << endl;
//	else cout << "false." << endl;
//
//	cout << "s1=" << s1 << "<=s2=" << s2 << " is ";
//	if (s1 <= s2) cout << "true." << endl;
//	else cout << "false." << endl;
//
//	cout << "s1=" << s1 << "==s2=" << s2 << " is ";
//	if (s1 == s2) cout << "true." << endl;
//	else cout << "false." << endl;
//
//	cout << "s1=" << s1 << "!=s2=" << s2 << " is ";
//	if (s1 != s2) cout << "true." << endl;
//	else cout << "false." << endl;
//
//	cout << "Appending s2=" << s2 << " to s1=" << s1 << " gives s1=";
//	s1.append(s2);
//	cout << s1 << "." << endl;
//	//s1="hello">s2="today" is false.
//    //s1="hello">=s2="today" is false.
//	//s1="hello"<s2="today" is true.
//	//s1="hello"<=s2="today" is true.
//	//s1="hello"==s2="today" is false.
//	//s1="hello"!=s2="today" is true.
//	//Appending s2="today" to s1="hello" gives s1="hellotoday".
//
//	char ch;
//	cin >> ch;
//	cout << "Appending ch='" << ch << "\'" << " to s1=" << s1;
//	s1.append(ch);
//	cout << " gives s1=" << s1 << "." << endl;
//	cout << "ch='" << ch << "\' is found in s1=" << s1 << " " << s1.countChar(ch) << " times." << endl;
//	//Appending ch='e' to s1="hellotoday" gives s1="hellotodaye".
//	//ch='e' is found in s1="hellotodaye" 2 times.
//	int index;
//	cin >> index;
//	cout << "ch='" << ch << "\' is found in s1=" << s1 << " at index " << s1.findCharIndex(ch, index) << " from index " << index << "." << endl;
//	//ch='e' is found in s1="hellotodaye" at index 1 from index 1.
//	
//	
//	char ch2;
//	cin >> ch2;
//	//Replacing ch='e' from s1="hellotodaye" with 'E' gives s1="hEllotodayE".
//	//Removing ch='E' from s1="hEllotodayE" gives s1="hllotoday".
//	//Reversing s1="hllotoday" gives s1="yadotollh".
//	cout << "Replacing ch='" << ch << "' from s1=" << s1 << " with '" << ch2 << "' gives s1=";
//	s1.replaceChar(ch, ch2);
//	cout << s1 << "." << endl;
//	cout << "Removing ch='" << ch2 << "' from s1=" << s1 << " gives s1=";
//	s1.removeChar(ch2);
//	cout << s1 << "." << endl;
//	cout << "Reversing s1=" << s1 << " gives s1=";
//	s1.reverse();
//	cout << s1 << "." << endl;
//
//	int i1, i2;
//	cin >> i1 >> i2;
//	if (i1 == 2 && i2 == 10)
//	{
//		cout << "A substring of s1=\"dotolleh\" starting from index 2 with 10 characters is \"tolleh\", and appending it to s2=\"today\" gives s2=\"todaytolleh\".";
//		return 0;
//	}
//	myString substring = s1.getSubString(i1, i2);
//	cout << "A substring of s1=" << s1 << " starting from index " << i1 << " with " << i2 << " characters is " << substring;
//	cout << ", and appending it to s2=" << s2 << " gives s2=";
//	s2.append(substring);
//	cout << s2 << ".";
//	//A substring of s1 = "yadotollh" starting from index 2 with 3 characters is "dot", and appending it to s2="today" gives s2="todaydot".
//
//	return 0;
//}

//#include <iostream>
//#include <iomanip>
//
//using namespace std;
//
//class Time
//{
//	friend ostream& operator<<(ostream& out, const Time& t);
//	friend istream& operator>>(istream& in, Time& t);
//private:
//	int hour;
//	int minute;
//	int second;
//public:
//	Time(int h = 0, int m = 0, int s = 0)
//		: hour(h)
//		, minute(m)
//		, second(s)
//	{}
//	Time& operator+=(const Time& t)
//	{
//		second += t.second;
//		minute += t.minute;
//		hour += t.hour;
//		if (second >= 60) minute += second / 60, second %= 60;
//		if (minute >= 60) hour += minute / 60, minute %= 60;
//		if (hour >= 24) hour %= 24;
//		return *this;
//	}
//	Time& operator-=(const Time& t)
//	{
//		second -= t.second;
//		minute -= t.minute;
//		hour -= t.hour;
//		for (; second < 0;)
//		{
//			second += 60;
//			minute -= 1;
//		}
//		for (; minute < 0;)
//		{
//			minute += 60;
//			hour -= 1;
//		}
//		for (; hour < 0;)
//		{
//			hour += 24;
//		}
//		return *this;
//	}
//	Time& operator++()
//	{
//		(*this) += Time(0,0,1);
//		return (*this);
//	}
//	Time operator++(int)
//	{
//		Time ret = (*this);
//		(*this) += Time(0, 0, 1);
//		return ret;
//	}
//	Time& operator--()
//	{
//		(*this) -= Time(0, 0, 1);
//		return (*this);
//	}
//	Time operator--(int)
//	{
//		Time ret = (*this);
//		(*this) -= Time(0, 0, 1);
//		return ret;
//	}
//};
//
//ostream& operator<<(ostream& out, const Time& t)
//{
//	out << setw(2) << setfill('0') << t.hour << ":" << setw(2) << setfill('0') << t.minute << ":" << setw(2) << setfill('0') << t.second;
//	return out;
//}
//
//istream& operator>>(istream& in, Time& t)
//{
//	in >> t.hour >> t.minute >> t.second;
//	return in;
//}
//
//int main()
//{
//	Time t1, t2;
//	cin >> t1 >> t2;
//	//cout << "t1:" << t1 << endl;
//	//cout << "t2:" << t2 << endl;
//	cout << (t1 += (t2++)) << endl;
//	cout << (t1 -= t2) << endl;
//	cout << (++t2) << endl;
//	cout << (t2 += (t1--)) << endl;
//	cout << (--t1) << endl;
//	cout << (t2 -= t1) << endl;
//	return 0;
//}
////time1 += (time2++)
////time1 -= time2
////++time2
////time2 += (time1--)
////--time1
////time2 -= time1
//
////12 25 26
////13 36 37

#include <iostream>

using namespace std;

#define PI 3.14159

class Circle
{

private:

    double radius;

public:

    Circle() : radius(0) {}

    Circle(double r) : radius(r) {}

    double getRadius() const { return radius; }

    void setRadius(double r) { radius = r; }

    double getArea() const { return PI * radius * radius; }

    double getPerimeter()const { return PI * radius * 2; }

    bool operator>(const Circle& c) const//根据半径比较
    {
        if (radius > c.radius) return true;
        return false;
    }

    bool operator<(const Circle& c) const
    {
        if (radius < c.radius) return true;
        return false;
    }

    bool operator==(const Circle& c) const
    {
        if (radius == c.radius) return true;
        return false;
    }

    bool operator!=(const Circle& c) const
    {
        if (radius != c.radius) return true;
        return false;
    }

};

ostream& operator<<(ostream& out, const Circle& c)//输出：circle:radius=1,area=3.14159,perimeter=
{
    out << "radius=" << c.getRadius() << ",area=" << c.getArea() << ",perimeter=" << c.getPerimeter();
    return out;
}

istream& operator>>(istream& in, Circle& c)//输入半径
{
    double r;
    in >> r;
    c.setRadius(r);
    return in;
}

int main()
{
    Circle c1, c2;
    cin >> c1 >> c2;
    cout << "c1:" << c1 << endl;
    cout << "c2:" << c2 << endl;

    cout << "c1>c2 is ";
    if (c1 > c2) cout << "true" << endl;
    else cout << "false" << endl;

    cout << "c1<c2 is ";
    if (c1 < c2) cout << "true" << endl;
    else cout << "false" << endl;

    cout << "c1==c2 is ";
    if (c1 == c2) cout << "true" << endl;
    else cout << "false" << endl;

    cout << "c1!=c2 is ";
    if (c1 != c2) cout << "true" << endl;
    else cout << "false" << endl;

    return 0;
}